package chai.ning.prequel;

import java.util.Arrays;

public class Container1 {

	private static final int DEFAULT_CAPACITY = 10;

	/* 声明一个默认 加载因子的常量 */
	private static final float DEFAULT_LOAD_FACTOR = 0.75F;

	private Object[] array;

	/* 声明一个Object 类的常量 用来填充旧数组 */
	private static final Object PRESEND = new Object();

	private int temp;

	/* 加载因子 */
	private float load_Factor;

	public StringBuffer buffer = new StringBuffer();

	public Container1() {
		this(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR);
	}

	public Container1(int initialCapacity) { // initialCapacity初始容量
		this(initialCapacity, DEFAULT_LOAD_FACTOR);
	}

	public Container1(int initialCapacity, float load_Factor) {
		super();
		if (initialCapacity <= 0) {
			throw new IllegalArgumentException(" 初始容量必须是正整数  ");
		}
		if (load_Factor <= 0 || load_Factor >= 1) {
			throw new IllegalArgumentException("加载因子必须在 0~1 之间");
		}
		array = new Object[DEFAULT_CAPACITY];
		Arrays.fill(array, PRESEND);
		this.load_Factor = load_Factor;
	}

	/* 在该方法中完成对数组的扩容 */
	private void grow() {
		int oldCapacity = array.length;
		// 当容器中元素个数容量的一定比例时 就要扩容了
		if (temp >= oldCapacity * load_Factor) {
			int newCapacity = oldCapacity + (oldCapacity >> 1);
			// 创建新数组
			Object[] array1 = new Object[newCapacity];
			// 填充新数组
			Arrays.fill(array1, PRESEND);
			// 将 array 数组中的[0 , temp)之间的元素复制到 array1 的[0 , temp)位置
			System.arraycopy(array, 0, array1, 0, temp);
			// 让实例变量array 指向新的数组
			array = array1;
		}
	}

	public void add(Object element) {
		grow();
		array[temp] = element;
		temp++;
	}

	/* 在指定位置插入一个新的元素 */
	public void add(int index, Object element) {
		if (index < 0 || index > temp) {
			throw new IndexOutOfBoundsException("新插入的元素索引只能是 [ 0 , " + temp + "]");
		}
		grow();
		System.arraycopy(array, index, array, index + 1, temp - index);
		array[index] = element;
		temp++;
	}

	/* 在指定位置替换旧元素 ，并返回旧元素 */
	public Object set(int index, Object element) {
		if (index < 0 | index > temp) {
			throw new IndexOutOfBoundsException("新插入的元素索引只能是 [ 0 , " + temp + "]");
		}
		grow();
		Object old = array[index];
		array[index] = element;
		return old;
	}

	/* 按索引搜索 返回 元素 */
	public Object get(int index) {
		if (index < 0 || index >= temp) {
			throw new IndexOutOfBoundsException("元素索引只能是 [ 0 , " + (temp - 1) + "]");
		}
		return "" + array[index];
	}

	/* * 删除指定索引处的元素并返回该元素 */
	public Object remove(int index) {
		if (index < 0 || index >= temp) {
			throw new IndexOutOfBoundsException("元素索引只能是 [ 0 , " + (temp - 1) + "]");
		}
		grow();
		Object old = array[index];
		System.arraycopy(array, index + 1, array, index, temp - index);
		temp--;
		return old;
	}

	/* 查找某个元素在容器中的索引(若未找到则返回-1) */
	public int indexOf( Object element ) {
		for( int i = 0;i<temp ; i++) {
			Object e = array[ i ];
			if( e.equals( element ) ) { // 这里的"相等"判断完全依赖于equals方法
				return i ; // 返回当前元素的索引(同时方法立即结束)
			}
		}
		return -1;
	}
	
	
	/* 判断当前容器中是否包含指定的元素 */
	public boolean contains( Object element ) {
		return indexOf( element ) != -1;
	}
	
	/* 删除指定的元素 */
	public void remove( Object element ) {
		int index = indexOf( element );
		if( index != -1 ) {
			this.remove( index);
		}else {
			System.out.println( "空" );
		}
	}
	
	@Override
	public String toString() {
		buffer.setLength(0);
		buffer.append("[");
		for (int i = 0; i < temp; i++) {
			buffer.append(array[i]);
			if (i < temp - 1) {
				buffer.append(",");
			}
		}
		buffer.append("]");
		return buffer.toString();
	}

	public int capacity() {
		return array.length;
	}

	public int size() {
		return temp;
	}

	public boolean isEmpty() {
		if (temp == 0) {
			return true;
		}
		return false;
	}

}
